home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / dev / src / GLperf3.12-src.lha / GLperf / Test.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-09-18  |  21.4 KB  |  924 lines
  1. /*
  2.  *   (C) COPYRIGHT International Business Machines Corp. 1993
  3.  *   All Rights Reserved
  4.  *   Licensed Materials - Property of IBM
  5.  *   US Government Users Restricted Rights - Use, duplication or
  6.  *   disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
  7.  
  8. //
  9. // Permission to use, copy, modify, and distribute this software and its
  10. // documentation for any purpose and without fee is hereby granted, provided
  11. // that the above copyright notice appear in all copies and that both that
  12. // copyright notice and this permission notice appear in supporting
  13. // documentation, and that the name of I.B.M. not be used in advertising
  14. // or publicity pertaining to distribution of the software without specific,
  15. // written prior permission. I.B.M. makes no representations about the
  16. // suitability of this software for any purpose.  It is provided "as is"
  17. // without express or implied warranty.
  18. //
  19. // I.B.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  20. // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL I.B.M.
  21. // BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  22. // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  23. // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  24. // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25. //
  26. // Author:  John Spitzer, IBM AWS Graphics Systems (Austin)
  27. //
  28. */
  29.  
  30. #if (defined(INC_REASON)) && (INC_REASON == INFO_ITEM_STRUCT)
  31.     InfoItemPtr infoItems;
  32.     int testType;
  33.     char *fileName;
  34.     int executeMode;
  35.     int iterations;
  36.     int numObjects;
  37.     int reps;
  38.     int time;
  39.     int loopFuncPtrs;   /* On or Off */
  40.     int loopUnroll;     /* [1,8]     */
  41.     int memAlignment;   /* Modulo 4096 value of the data alignment                        */
  42. #ifdef environ
  43. #undef environ
  44. #endif
  45.     EnvironmentInfo environ;
  46.     char* glperfVersion;
  47.     PrintfStringPtr userString;
  48.     int printModeDelta;
  49.     int printModeStateDelta;
  50.     int printModeMicrosec;
  51.     int printModePixels;
  52.     /* Members below this line aren't user settable */
  53.     char *usecPrint;
  54.     char *ratePrint;
  55.     char *usecPixelPrint;
  56.     char *ratePixelPrint;
  57.     Visual_ID previousVisual;
  58.     GLenum windType;
  59.     GLenum previousWindType;
  60.     int previousWinW;
  61.     int previousWinH;
  62.     int clearBefore;
  63.     /* Member functions */
  64.     struct _Test * (*Copy)(struct _Test *); /* pure virtual function */
  65.     void (*Execute)(struct _Test *);        /* pure virtual function */
  66.     void (*Initialize)(struct _Test *);     /* pure virtual function */
  67.     void (*Cleanup)(struct _Test *);        /* pure virtual function */
  68.     void (*SetExecuteFunc)(struct _Test *); /* pure virtual function */
  69.     int  (*SetState)(struct _Test *);       /* virtual function      */
  70.     void (*delete)(struct _Test *);         /* virtual function      */
  71.     float (*PixelSize)(struct _Test *);     /* virtual function      */
  72.     int (*TimesRun)(struct _Test *);      /* virtual function      */
  73. #elif (defined(INC_REASON)) && (INC_REASON == INFO_ITEM_ARRAY)
  74.     {
  75.         TestType,
  76.         "Test Type",
  77.         offset(testType),
  78.         Enumerated | NotSettable,
  79.         {
  80.             { ClearTest, "ClearTest" },
  81.             { TransformTest, "TransformTest" },
  82.             { PointsTest, "PointsTest" },
  83.             { LinesTest, "LinesTest" },
  84.             { LineLoopTest, "LineLoopTest" },
  85.             { LineStripTest, "LineStripTest" },
  86.             { TrianglesTest, "TrianglesTest" },
  87.             { TriangleStripTest, "TriangleStripTest" },
  88.             { TriangleFanTest, "TriangleFanTest" },
  89.             { QuadsTest, "QuadsTest" },
  90.             { QuadStripTest, "QuadStripTest" },
  91.             { PolygonTest, "PolygonTest" },
  92.             { DrawPixelsTest, "DrawPixelsTest" },
  93.             { CopyPixelsTest, "CopyPixelsTest" },
  94.             { BitmapTest, "BitmapTest" },
  95.             { TextTest, "TextTest" },
  96.             { ReadPixelsTest, "ReadPixelsTest" },
  97.             { TexImageTest, "TexImageTest" },
  98.             { End }
  99.         },
  100.         { ClearTest }
  101.     },
  102.     {
  103.         FileName,
  104.         "GLperf Script File Name",
  105.         offset(fileName),
  106.         StringType,
  107.         {
  108.             { NotUsed }
  109.         },
  110.         { NotUsed, (GLfloat)NotUsed, (char*)"None" }
  111.     },
  112.     {
  113.         UserString,
  114.         "User Defined String",
  115.         offset(userString),
  116.         PrintfStringType | NoPrint,
  117.         {
  118.             { NotUsed }
  119.         },
  120.         { NotUsed, (GLfloat)NotUsed, (char*)"None" }
  121.     },
  122.     {
  123.         PrintModeDelta,
  124.         "Print Mode Delta",
  125.         offset(printModeDelta),
  126.         Enumerated,
  127.         {
  128.             { False,                    "False" },
  129.             { True,                     "True" },
  130.             { End }
  131.         },
  132.         { False }
  133.     },
  134.     {
  135.         PrintModeStateDelta,
  136.         "Print Mode Delta from Default State",
  137.         offset(printModeStateDelta),
  138.         Enumerated,
  139.         {
  140.             { False,                    "False" },
  141.             { True,                     "True" },
  142.             { End }
  143.         },
  144.         { False }
  145.     },
  146.     {
  147.         PrintModeMicrosec,
  148.         "Print Mode Microseconds",
  149.         offset(printModeMicrosec),
  150.         Enumerated,
  151.         {
  152.             { False,                    "False" },
  153.             { True,                     "True" },
  154.             { End }
  155.         },
  156.         { False }
  157.     },
  158.     {
  159.         PrintModePixels,
  160.         "Print Mode Pixels Per Second",
  161.         offset(printModePixels),
  162.         Enumerated,
  163.         {
  164.             { False,                    "False" },
  165.             { True,                     "True" },
  166.             { End }
  167.         },
  168.         { False }
  169.     },
  170.     {
  171.         GLperfVersion,
  172.         "GLperf Version",
  173.         offset(glperfVersion),
  174.         StringType | NotSettable,
  175.         {
  176.             { NotUsed }
  177.         },
  178.         { NotUsed, (GLfloat)NotUsed, (char*)"3.1.2" }
  179.     },
  180.     {
  181.         ExecuteMode,
  182.         "Execute Mode",
  183.         offset(executeMode),
  184.         Enumerated,
  185.         {
  186.             { Immediate,            "Immediate" },
  187.             { Compile,              "Compile" },
  188.             { CallList,             "CallList" },
  189.             { CompileExecute,       "CompileExecute" },
  190.             { DestroyList,          "DestroyList" },
  191.             { End }
  192.         },
  193.         { Immediate }
  194.     },
  195.     {
  196.         Objs,
  197.         "Number of Objects",
  198.         offset(numObjects),
  199.         RangedInteger,
  200.         {
  201.             { 1 }, /* minimum value */
  202.             { 1000000 }  /* maximum value */
  203.         },
  204.         { 1 }
  205.     },
  206.     {
  207.         Iterations,
  208.         "Iterations",
  209.         offset(iterations),
  210.         RangedInteger | NoPrint,
  211.         {
  212.             { 1 }, /* minimum value */
  213.             { 100000 }, /* maximum value */
  214.         },
  215.         { -1 }
  216.     },
  217.     {
  218.         Reps,
  219.         "Repetitions",
  220.         offset(reps),
  221.         RangedInteger | NoPrint,
  222.         {
  223.             { 1 }, /* minimum value */
  224.             { 100000 }, /* maximum value */
  225.         },
  226.         { 1 }
  227.     },
  228.     {
  229.         MinimumTime,
  230.         "Test Time",
  231.         offset(time),
  232.         RangedInteger | NoPrint,
  233.         {
  234.             { 1 }, /* minimum value */
  235.             { 100000 }, /* maximum value */
  236.         },
  237.         { 5 }
  238.     },
  239.     {
  240.         LoopUnroll,
  241.         "Vertices Unrolled in Inner Loop",
  242.         offset(loopUnroll),
  243.         RangedInteger,
  244.         {
  245.             { 1 },
  246. #ifdef FULL_UNROLL_PATHS
  247.             { 8 }
  248. #else
  249.         { 1 }
  250. #endif
  251.         },
  252.         { 1 }
  253.     },
  254.     {
  255.         LoopFuncPtrs,
  256.         "Function Pointers Used in Inner Loop",
  257.         offset(loopFuncPtrs),
  258.         Enumerated,
  259.         {
  260.             { Off,                      "Off" },
  261. #ifdef FULL_FUNCPTR_PATHS
  262.             { On,                       "On" },
  263. #endif
  264.             { End }
  265.         },
  266.         { Off }
  267.     },
  268.     {
  269.         DataAlignment,
  270.         "Modulo 4096 of Data Alignment",
  271.         offset(memAlignment),
  272.         RangedInteger,
  273.         {
  274.         { 0 },
  275.         { 4095 }
  276.         },
  277.         { 0 }
  278.     },
  279.     {
  280.         Month,
  281.         "Month",
  282.         offset(environ.month),
  283.         RangedInteger | NotSettable,
  284.         {
  285.           { 1 },
  286.           { 12 }
  287.         },
  288.         { -1 }
  289.     },
  290.     {
  291.         Day,
  292.         "Day",
  293.         offset(environ.day),
  294.         RangedInteger | NotSettable,
  295.         {
  296.           { 1 },
  297.           { 31 }
  298.         },
  299.         { -1 }
  300.     },
  301.     {
  302.         Year,
  303.         "Year",
  304.         offset(environ.year),
  305.         RangedInteger | NotSettable,
  306.         {
  307.           { 1994 },
  308.           { 2010 }
  309.         },
  310.         { -1 }
  311.     },
  312.     {
  313.         Host,
  314.         "Host",
  315.         offset(environ.host),
  316.         StringType | NotSettable,
  317.         {
  318.             { NotUsed }
  319.         },
  320.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  321.     },
  322.     {
  323.         HostOperatingSystem,
  324.         "Operating System",
  325.         offset(environ.hostOperatingSystem),
  326.         StringType | NotSettable,
  327.         {
  328.             { NotUsed }
  329.         },
  330.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  331.     },
  332.     {
  333.         HostOperatingSystemVersion,
  334.         "Operating System Version",
  335.         offset(environ.hostOperatingSystemVersion),
  336.         StringType | NotSettable,
  337.         {
  338.             { NotUsed }
  339.         },
  340.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  341.     },
  342.     {
  343.         HostVendor,
  344.         "Host Vendor",
  345.         offset(environ.hostVendor),
  346.         StringType | NotSettable,
  347.         {
  348.             { NotUsed }
  349.         },
  350.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  351.     },
  352.     {
  353.         HostModel,
  354.         "Host Model",
  355.         offset(environ.hostModel),
  356.         StringType | NotSettable,
  357.         {
  358.             { NotUsed }
  359.         },
  360.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  361.     },
  362.     {
  363.         HostCPU,
  364.         "Host CPU",
  365.         offset(environ.hostCPU),
  366.         StringType | NotSettable,
  367.         {
  368.             { NotUsed }
  369.         },
  370.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  371.     },
  372.     {
  373.         HostCPUCount,
  374.         "Host CPU Count",
  375.         offset(environ.hostCPUCount),
  376.         StringType | NotSettable,
  377.         {
  378.             { NotUsed }
  379.         },
  380.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  381.     },
  382.     {
  383.         HostMemorySize,
  384.         "Host Memory Size",
  385.         offset(environ.hostMemorySize),
  386.         UnrangedInteger | NotSettable,
  387.         {
  388.             { NotUsed }
  389.         },
  390.         { -1 }
  391.     },
  392.     {
  393.         HostPrimaryCacheSize,
  394.         "Host Primary Cache Size",
  395.         offset(environ.hostPrimaryCacheSize),
  396.         StringType | NotSettable,
  397.         {
  398.             { NotUsed }
  399.         },
  400.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  401.     },
  402.     {
  403.         HostSecondaryCacheSize,
  404.         "Host Secondary Cache Size",
  405.         offset(environ.hostSecondaryCacheSize),
  406.         StringType | NotSettable,
  407.         {
  408.             { NotUsed }
  409.         },
  410.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  411.     },
  412.     {
  413.         WindowSystem,
  414.         "Window System",
  415.         offset(environ.windowSystem),
  416.         StringType | NotSettable,
  417.         {
  418.             { NotUsed }
  419.         },
  420.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  421.     },
  422.     {
  423.         DriverVersion,
  424.         "Driver Version",
  425.         offset(environ.driverVersion),
  426.         StringType | NotSettable,
  427.         {
  428.             { NotUsed }
  429.         },
  430.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  431.     },
  432.     {
  433.         OpenGLVendor,
  434.         "OpenGL Vendor",
  435.         offset(environ.glVendor),
  436.         StringType | NotSettable,
  437.         {
  438.             { NotUsed }
  439.         },
  440.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  441.     },
  442.     {
  443.         OpenGLVersion,
  444.         "OpenGL Version",
  445.         offset(environ.glVersion),
  446.         StringType | NotSettable,
  447.         {
  448.             { NotUsed }
  449.         },
  450.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  451.     },
  452.     {
  453.         OpenGLExtensions,
  454.         "OpenGL Extensions",
  455.         offset(environ.glExtensions),
  456.         StringType | NotSettable,
  457.         {
  458.             { NotUsed }
  459.         },
  460.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  461.     },
  462.     {
  463.         OpenGLRenderer,
  464.         "OpenGL Renderer",
  465.         offset(environ.glRenderer),
  466.         StringType | NotSettable,
  467.         {
  468.             { NotUsed }
  469.         },
  470.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  471.     },
  472.     {
  473.         OpenGLClientVendor,
  474.         "OpenGL Client Vendor",
  475.         offset(environ.glClientVendor),
  476.         StringType | NotSettable,
  477.         {
  478.             { NotUsed }
  479.         },
  480.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  481.     },
  482.     {
  483.         OpenGLClientVersion,
  484.         "OpenGL Client Version",
  485.         offset(environ.glClientVersion),
  486.         StringType | NotSettable,
  487.         {
  488.             { NotUsed }
  489.         },
  490.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  491.     },
  492.     {
  493.         OpenGLClientExtensions,
  494.         "OpenGL Client Extensions",
  495.         offset(environ.glClientExtensions),
  496.         StringType | NotSettable,
  497.         {
  498.             { NotUsed }
  499.         },
  500.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  501.     },
  502.     {
  503.         GLUVersion,
  504.         "GLU Version",
  505.         offset(environ.gluVersion),
  506.         StringType | NotSettable,
  507.         {
  508.             { NotUsed }
  509.         },
  510.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  511.     },
  512.     {
  513.         GLUExtensions,
  514.         "GLU Extensions",
  515.         offset(environ.gluExtensions),
  516.         StringType | NotSettable,
  517.         {
  518.             { NotUsed }
  519.         },
  520.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  521.     },
  522.     {
  523.         DirectRender,
  524.         "Direct Rendering",
  525.         offset(environ.directRender),
  526.         Enumerated,
  527.         {
  528.             { True,     "True" },
  529.             { False,    "False" },
  530.             { End }
  531.         },
  532.         { True }
  533.     },
  534.     {
  535.         DoubleBuffer,
  536.         "Double Buffer",
  537.         offset(environ.bufConfig.doubleBuffer),
  538.         Enumerated,
  539.         {
  540.             { True,     "True" },
  541.             { False,    "False" },
  542.             { End }
  543.         },
  544.         { True }
  545.     },
  546.     {
  547.         Stereo,
  548.         "Stereo",
  549.         offset(environ.bufConfig.stereo),
  550.         Enumerated,
  551.         {
  552.             { True,     "True" },
  553.             { False,    "False" },
  554.             { End }
  555.         },
  556.         { False }
  557.     },
  558.     {
  559.         Rgba,
  560.         "RGBA",
  561.         offset(environ.bufConfig.rgba),
  562.         Enumerated,
  563.         {
  564.             { True,     "True" },
  565.             { False,    "False" },
  566.             { End }
  567.         },
  568.         { True }
  569.     },
  570.     {
  571.         IndexSize,
  572.         "Color Index Size",
  573.         offset(environ.bufConfig.indexSize),
  574.         UnrangedInteger,
  575.         {
  576.             { NotUsed }
  577.         },
  578.         { 0 }
  579.     },
  580.     {
  581.         RedSize,
  582.         "Red Size",
  583.         offset(environ.bufConfig.redSize),
  584.         UnrangedInteger,
  585.         {
  586.             { NotUsed }
  587.         },
  588.         { 1 }
  589.     },
  590.     {
  591.         GreenSize,
  592.         "Green Size",
  593.         offset(environ.bufConfig.greenSize),
  594.         UnrangedInteger,
  595.         {
  596.             { NotUsed }
  597.         },
  598.         { 1 }
  599.     },
  600.     {
  601.         BlueSize,
  602.         "Blue Size",
  603.         offset(environ.bufConfig.blueSize),
  604.         UnrangedInteger,
  605.         {
  606.             { NotUsed }
  607.         },
  608.         { 1 }
  609.     },
  610.     {
  611.         AlphaSize,
  612.         "Alpha Size",
  613.         offset(environ.bufConfig.alphaSize),
  614.         UnrangedInteger,
  615.         {
  616.             { NotUsed }
  617.         },
  618.         { 0 }
  619.     },
  620.     {
  621.         AccumRedSize,
  622.         "Accum Red Size",
  623.         offset(environ.bufConfig.accumRedSize),
  624.         UnrangedInteger,
  625.         {
  626.             { NotUsed }
  627.         },
  628.         { 0 }
  629.     },
  630.     {
  631.         AccumGreenSize,
  632.         "Accum Green Size",
  633.         offset(environ.bufConfig.accumGreenSize),
  634.         UnrangedInteger,
  635.         {
  636.             { NotUsed }
  637.         },
  638.         { 0 }
  639.     },
  640.     {
  641.         AccumBlueSize,
  642.         "Accum Blue Size",
  643.         offset(environ.bufConfig.accumBlueSize),
  644.         UnrangedInteger,
  645.         {
  646.             { NotUsed }
  647.         },
  648.         { 0 }
  649.     },
  650.     {
  651.         AccumAlphaSize,
  652.         "Accum Alpha Size",
  653.         offset(environ.bufConfig.accumAlphaSize),
  654.         UnrangedInteger,
  655.         {
  656.             { NotUsed }
  657.         },
  658.         { 0 }
  659.     },
  660.     {
  661.         DepthSize,
  662.         "Depth Size",
  663.         offset(environ.bufConfig.depthSize),
  664.         UnrangedInteger,
  665.         {
  666.             { NotUsed }
  667.         },
  668.         { 1 }
  669.     },
  670.     {
  671.         StencilSize,
  672.         "Stencil Size",
  673.         offset(environ.bufConfig.stencilSize),
  674.         UnrangedInteger,
  675.         {
  676.             { NotUsed }
  677.         },
  678.         { 0 }
  679.     },
  680.     {
  681.         AuxBuffers,
  682.         "Auxiliary Buffer Count",
  683.         offset(environ.bufConfig.auxBuffers),
  684.         UnrangedInteger,
  685.         {
  686.             { NotUsed }
  687.         },
  688.         { 0 }
  689.     },
  690. #ifdef GL_SGIS_multisample
  691.     {
  692.         SampleBuffers,
  693.         "Multisample Buffer Count",
  694.         offset(environ.bufConfig.sampleBuffers),
  695.         RangedInteger,
  696.         {
  697.             { 0 },
  698.         { 1 }
  699.         },
  700.         { 0 }
  701.     },
  702.     {
  703.         SamplesPerPixel,
  704.         "Multisamples Per Pixel",
  705.         offset(environ.bufConfig.numSamples),
  706.         RangedInteger,
  707.         {
  708.             { 0 },
  709.         { 16 }
  710.         },
  711.         { 0 }
  712.     },
  713. #endif
  714.     {
  715.         FrameBufferLevel,
  716.         "Frame BufferLevel",
  717.         offset(environ.bufConfig.level),
  718.         UnrangedInteger,
  719.         {
  720.             { NotUsed }
  721.         },
  722.         { 0 }
  723.     },
  724. #if defined(XWINDOWS)
  725.     {
  726.         VisualId,
  727.         "Visual ID",
  728.         offset(environ.bufConfig.visualId),
  729.         UnrangedHexInteger,
  730.         {
  731.             { NotUsed }
  732.         },
  733.         { NoVisual }
  734.     },
  735.     {
  736.         VisualClass,
  737.         "Visual Class",
  738.         offset(environ.bufConfig.visualClass),
  739.         Enumerated | NotSettable,
  740.         {
  741.             { StaticGray,       "StaticGray" },
  742.             { GrayScale,        "GrayScale" },
  743.             { StaticColor,      "StaticColor" },
  744.             { PseudoColor,      "PseudoColor" },
  745.             { TrueColor,        "TrueColor" },
  746.             { DirectColor,      "DirectColor" },
  747.             { End }
  748.         },
  749.         { -1 }
  750.     },
  751. #endif
  752.     {
  753.         WindowWidth,
  754.         "Window Width",
  755.         offset(environ.windowWidth),
  756.         RangedInteger,
  757.         {
  758.             { 100 }, /* minimum value */
  759.             { 2048 }, /* maximum value */
  760.         },
  761.         { 384 }
  762.     },
  763.     {
  764.         WindowHeight,
  765.         "Window Height",
  766.         offset(environ.windowHeight),
  767.         RangedInteger,
  768.         {
  769.             { 100 }, /* minimum value */
  770.             { 2048 }, /* maximum value */
  771.         },
  772.         { 384 }
  773.     },
  774.     {
  775.         ScreenWidth,
  776.         "Screen Width",
  777.         offset(environ.screenWidth),
  778.         UnrangedInteger | NotSettable,
  779.         {
  780.             { NotUsed }
  781.         },
  782.         { -1 }
  783.     },
  784.     {
  785.         ScreenHeight,
  786.         "Screen Height",
  787.         offset(environ.screenHeight),
  788.         UnrangedInteger | NotSettable,
  789.         {
  790.             { NotUsed }
  791.         },
  792.         { -1 }
  793.     },
  794. #if defined(XWINDOWS)
  795.     {
  796.         DisplayName,
  797.         "Display",
  798.         offset(environ.display),
  799.         StringType | NotSettable,
  800.         {
  801.             { NotUsed }
  802.         },
  803.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  804.     },
  805.     {
  806.         OpenGLServerVendor,
  807.         "OpenGL Server Vendor",
  808.         offset(environ.glServerVendor),
  809.         StringType | NotSettable,
  810.         {
  811.             { NotUsed }
  812.         },
  813.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  814.     },
  815.     {
  816.         OpenGLServerVersion,
  817.         "OpenGL Server Version",
  818.         offset(environ.glServerVersion),
  819.         StringType | NotSettable,
  820.         {
  821.             { NotUsed }
  822.         },
  823.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  824.     },
  825.     {
  826.         OpenGLServerExtensions,
  827.         "OpenGL Server Extensions",
  828.         offset(environ.glServerExtensions),
  829.         StringType | NotSettable,
  830.         {
  831.             { NotUsed }
  832.         },
  833.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  834.     },
  835.     {
  836.         GLXVersion,
  837.         "GLX Server Version",
  838.         offset(environ.glxVersion),
  839.         StringType | NotSettable,
  840.         {
  841.             { NotUsed }
  842.         },
  843.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  844.     },
  845.     {
  846.         GLXExtensions,
  847.         "GLX Server Extensions",
  848.         offset(environ.glxExtensions),
  849.         StringType | NotSettable,
  850.         {
  851.             { NotUsed }
  852.         },
  853.         { NotUsed, (GLfloat)NotUsed, (char*)"unknown" }
  854.     },
  855.     {
  856.         ScreenNumber,
  857.         "Screen Number",
  858.         offset(environ.screenNumber),
  859.         UnrangedInteger | NotSettable,
  860.         {
  861.             { NotUsed }
  862.         },
  863.         { -1 }
  864.     },
  865.     {
  866.         SharedMemConnection,
  867.         "Shared Memory Connection",
  868.         offset(environ.sharedMemConnection),
  869.         Enumerated | NotSettable,
  870.         {
  871.             { True,     "True" },
  872.             { False,    "False" },
  873.             { End }
  874.         },
  875.         { False }
  876.     },
  877. #endif
  878. #else  /* INC_REASON not defined, treat as plain include */
  879. #ifndef _Test_h
  880. #define _Test_h
  881.  
  882. #include "InfoItem.h"
  883. #ifdef WIN32
  884. #include <windows.h>
  885. #include <gl\glaux.h>
  886. #elif __amigaos__
  887. #include <gl/glaux.h>
  888. #else
  889. #include "aux.h"
  890. #endif
  891. #include "Env.h"
  892. #include "Printf.h"
  893.  
  894. typedef struct _Test {
  895. #define INC_REASON INFO_ITEM_STRUCT
  896. #include "Test.h"
  897. #undef INC_REASON
  898. } Test, *TestPtr;
  899.  
  900. #include "General.h"
  901. #include "Print.h"
  902. #include "TestName.h"
  903. #include "PropName.h"
  904. #include "Global.h"
  905. #include "AttrName.h"
  906. #ifdef WIN32
  907. #include <windows.h>
  908. #endif
  909. #include <GL/gl.h>
  910. #include <GL/glu.h>
  911. #include "Random.h"
  912. #include "Timer.h"
  913.  
  914. /* These were non-virtual member functions */
  915. void new_Test(TestPtr this);
  916. void delete_Test(TestPtr this);
  917. int Test__SetState(TestPtr this);
  918. int Test__TimesRun(TestPtr this);
  919. void Test__Calibrate(TestPtr);
  920. float Test__TimedRun(TestPtr);
  921. int Test__SetupRunPrint(TestPtr, TestPtr, int);
  922. #endif /* file not already included */
  923. #endif /* INC_REASON not defined */
  924.